home *** CD-ROM | disk | FTP | other *** search
/ Skunkware 5 / Skunkware 5.iso / src / Tools / freeWAIS-sf-1.1 / ir / sersrch.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-12-13  |  40.7 KB  |  1,399 lines
  1.  
  2. /* Copyright (c) CNIDR (Work in progress) */
  3.  
  4. /* WIDE AREA INFORMATION SERVER SOFTWARE
  5.    No guarantees or restrictions.  See the readme file for the full standard
  6.    disclaimer.    
  7.    Brewster@think.com
  8. */
  9.  
  10.  
  11. /* implements the search part of irext.h 
  12.    (search_word and finished_search_word)
  13.    -brewster
  14.  
  15. Split from irsearch.c
  16.  
  17.    5/31/91 Added scale_scores.  Fixed document_score_array to long.
  18.    7/8/91 Removed scale_scores, handled in search_word with doc_id > 0.
  19.    2/4/92 Made document_score_array a double.
  20.  
  21.    - Jonny G
  22.  * $Log: sersrch.c,v $
  23.  * Revision 1.54  1994/12/13  17:03:58  pfeifer
  24.  * *** empty log message ***
  25.  *
  26.  * Revision 1.53  1994/11/14  15:58:17  pfeifer
  27.  * Patch by Archie Warnoc in c.i.w (must be made size dependent?)
  28.  *
  29.  * Revision 1.52  1994/09/06  16:53:48  pfeifer
  30.  * Syn cache patch
  31.  *
  32.  * Revision 1.51  1994/08/05  09:46:46  pfeifer
  33.  * No more 'MAXINT redefined' complaints.
  34.  *
  35.  * Revision 1.50  1994/08/05  07:12:38  pfeifer
  36.  * Release beta 04
  37.  *
  38.  * Revision 1.49  1994/07/13  07:52:36  huynh1
  39.  * Uli
  40.  *
  41.  * Revision 1.48  1994/05/27  09:13:21  huynh1
  42.  * boolean code updated. beta
  43.  *
  44.  * Revision 1.47  1994/05/26  14:33:57  huynh1
  45.  * search_word updated (read_weight_from_stream).
  46.  * beta.
  47.  *
  48.  * Revision 1.46  1994/05/20  12:49:58  pfeifer
  49.  * beta
  50.  *
  51.  * Revision 1.45  1994/05/19  12:44:39  huynh1
  52.  * search_word updated.
  53.  *
  54.  * Revision 1.44  1994/05/18  17:28:13  huynh1
  55.  * new term weighting
  56.  * higher retrieval quality.
  57.  *
  58.  * Revision 1.40  1994/04/28  16:28:01  huynh1
  59.  * stemming
  60.  *
  61.  * Revision 1.39  1994/04/06  23:52:04  huynh1
  62.  * 08, autoconf, Uli
  63.  *
  64.  * Revision 1.38  1994/03/23  13:11:07  pfeifer
  65.  * removed include iso.h
  66.  *
  67.  * Revision 1.37  1994/03/08  20:46:12  huynh1
  68.  * Patchlevel 04
  69.  *
  70.  * Revision 1.36  1994/02/14  10:33:04  huynh1
  71.  * new code for field concept added.
  72.  *
  73.  * Revision 1.36  1993/12/08  17:38:00  huynh1
  74.  * bug by mixing literal and nested boolean corrected!
  75.  *
  76.  * Revision 1.10  1993/10/13  14:14:20  huynh1
  77.  * new code added for encapsulated boolean queries and
  78.  * modified literal search
  79.  *
  80.  * Revision 1.3  1993/07/13  08:19:56  pfeifer
  81.  * Sicherung vor Aenderungen Tung
  82.  *
  83.  * Revision 1.1  1993/02/16  15:05:35  freewais
  84.  * Initial revision
  85.  *
  86.  * Revision 1.24  92/04/28  16:56:54  morris
  87.  * added boolean to serial engine
  88.  * 
  89.  * Revision 1.23  92/03/15  10:15:18  jonathan
  90.  * Added Simon Spero's ASSIGN replacement for read_bytes.
  91.  * 
  92.  * Revision 1.22  92/03/05  07:09:54  shen
  93.  * add two more dummy arguments to call to init_search_engine
  94.  * 
  95.  * Revision 1.21  92/02/12  17:29:52  jonathan
  96.  * Conditionalized inclusion of object code.
  97.  * 
  98.  * Revision 1.20  92/02/12  13:40:06  jonathan
  99.  * Added "$Log" so RCS will put the log message in the header
  100.  * 
  101. */
  102.  
  103. #include "cutil.h"
  104. #include "irfiles.h"
  105. #ifdef BIO
  106. #include "irtfiles.h" /* dgg, for wordDelimiter */
  107. #endif
  108. #include "irsearch.h"
  109. #include "irext.h"
  110. #include "byte_order.h"
  111. /* #include <string.h> */
  112. #include <ctype.h>
  113.  
  114. #include <math.h>
  115.  
  116. #ifdef MAXINT
  117. #undef MAXINT
  118. #endif
  119. #define MAXINT (unsigned long)2^(sizeof(long)*8-1)
  120. #define VALUE 1000000L
  121. /* francois */
  122. #include "stemmer.h"   
  123.  
  124. /* tung, 10/93 */
  125. #ifdef NESTED_BOOLEANS
  126. #include "boolean_op.h"
  127. #endif
  128. /* tung, 10/93 */
  129.  
  130. #ifdef FIELDS /* tung, 1/94 */
  131. #include "field_search.h"
  132. #endif
  133.  
  134. #ifdef NEW_WEIGHT /* tung, 5/94 */
  135. #include "weight.h"
  136. #endif
  137.  
  138. #ifdef BOOL
  139. #include "obj.h"
  140. #include "irparse.h"
  141. object* currentQuery = NULL; /* kludge until irext goes away */
  142. #endif /* def BOOL */
  143.  
  144. /* weighting for relevant document terms - 
  145.    this may become a parameter to the query.
  146. */
  147.  
  148. #define RF_WEIGHTING 0.1
  149.  
  150. /* ==================================
  151.  * ===  Initialization Functions  ===
  152.  * ==================================*/
  153.  
  154.  
  155. long init_search_engine(file, initialize, for_search, cm_mem_percent, 
  156. text_size, grow_percent)
  157.   char* file;
  158.   boolean initialize;
  159.   boolean for_search;
  160.   long cm_mem_percent;  /* unused */
  161.   long text_size;     /* unused */
  162.   long grow_percent;  /* unused */
  163. {
  164.   static boolean inited = false;
  165.  
  166.   if (inited == false)
  167.    { 
  168. #ifdef BOOL
  169.      initObj();
  170.      initBool();
  171. #endif
  172.      inited = true;
  173.    }
  174.  
  175.   return(0);
  176. }
  177.  
  178. long finished_search_engine()
  179. {
  180. #ifdef CACHE_SYN
  181.   /* clean up shared memory segments */
  182.   if (cacheSynId) {
  183.     int i;
  184.     char *pcs;
  185.     t_cacheSyn *syn_Cache, *cs;
  186.     if ((syn_Cache = (t_cacheSyn *) shmat (cacheSynId, 0, 0)) != 
  187.     ((t_cacheSyn *)-1)) {
  188.       pcs = (char *) syn_Cache;
  189.       for (i = 0, cs = (t_cacheSyn *) pcs; i < MAX_SYN_CACHE && cs->id; 
  190.        i++, pcs += sizeof(t_cacheSyn), cs = (t_cacheSyn *) pcs)
  191.     if (shmctl(cs->id, IPC_RMID, (t_cacheSyn *)0) < 0)
  192.       waislog (WLOG_HIGH, WLOG_WARNING, "Error detatching shared memory segment (id=%d)", cs->id);
  193.       if (shmctl(cacheSynId, IPC_RMID, (t_cacheSyn *)0) < 0)
  194.     waislog (WLOG_HIGH, WLOG_WARNING, "Error detatching shared memory segment (id=%d)", cacheSynId);
  195.     }
  196.   }
  197. #endif
  198.   return(0);
  199. }
  200.  
  201.  
  202. /*
  203.  *  ext_open_database: see irext.h
  204.  */
  205.  
  206. long ext_open_database (db, initialize, for_search)
  207.      database *db;
  208.      boolean initialize;
  209.      boolean for_search;
  210. { /* this has to deal with the .inv file */
  211.   char file[MAX_FILE_NAME_LEN];
  212.  
  213.   if(initialize) /* make a new one */
  214.     db->index_stream = s_fopen(index_filename(file, db), "w+b");
  215.   else if(for_search) /* just search */
  216.     db->index_stream = s_fopen(index_filename(file, db), "rb");
  217.   else /* write to an existing db */
  218.     db->index_stream = s_fopen(index_filename(file, db), "r+b");
  219.  
  220.   if (db->index_stream == NULL) {
  221.     waislog(WLOG_HIGH, WLOG_ERROR,"2can't open the inverted index file %s\n", 
  222.         file);
  223.     disposeDatabase(db);
  224.     return(1);
  225.   }
  226.   return(0);
  227. }
  228.   
  229.  
  230.  
  231. /*
  232.  *  ext_close_database: see irext.h
  233.  */
  234.  
  235. long ext_close_database (db)
  236.      database *db;
  237. {
  238.   return(0);
  239. }
  240.  
  241. char *database_file(database_name)
  242.      char *database_name;
  243. {
  244.   return(database_name);
  245. }
  246.   
  247. /*===========================*
  248.  *===  Setting Paramters  ===*
  249.  *===========================*/
  250.  
  251. long max_hit_retrieved = 0;
  252. char **srcs = NULL;
  253.  
  254. long set_query_parameter (mask, parameters)
  255.      long mask;
  256.      query_parameter_type * parameters;
  257. {
  258.   switch (mask)
  259.     {
  260.     case SET_MAX_RETRIEVED_MASK:
  261.       max_hit_retrieved = parameters->max_hit_retrieved;
  262.       return(0);
  263.       break;
  264.     case SET_SELECT_SOURCE:
  265.       if(NULL != srcs){
  266.     if(NULL != srcs[0])
  267.       s_free(srcs[0]);
  268.     s_free(srcs);
  269.       }
  270.       srcs = parameters->srcs;
  271.       break;
  272.     default:
  273.       return(-1);
  274.       break;
  275.     }
  276.   return(0);
  277. }
  278.  
  279. /*==============================*
  280.  *===  Document Score Array  ===*
  281.  *==============================*/
  282.  
  283. double *document_score_array = NULL;
  284. long document_score_array_len = 0;
  285. #ifdef NESTED_BOOLEANS /* tung, 1/94 */
  286. double *NumPart_score_array = NULL;
  287. #else
  288. #ifdef BOOLEANS
  289. double *prev_score_array = NULL;                    /* 12/91 GS TLG */
  290. #endif
  291. #endif
  292.  
  293. #ifdef NESTED_BOOLEANS
  294. /* tung, 10/93 */
  295. search_result_struct *search_result_array = NULL;
  296. long operand_id = 0;
  297.  
  298. static void clear_search_result_array _AP((long* number_of_elements));
  299. static void clear_search_result_array(number_of_elements)
  300.      long* number_of_elements;
  301. {
  302.   long count;
  303.   
  304.   if(*number_of_elements > 1 && search_result_array != NULL) {
  305.     for(count=0; count < *number_of_elements; count++) {
  306.       if(search_result_array[count].doc_ids_array != NULL) 
  307.         s_free(search_result_array[count].doc_ids_array);
  308.     }
  309.     s_free(search_result_array);
  310.   }
  311.   *number_of_elements = 1;
  312. }
  313.  
  314. static void make_search_result_array _AP((long length));
  315. static void make_search_result_array(length)
  316.      long length;
  317. {
  318.   if(search_result_array == NULL) {
  319.     search_result_array = 
  320.       (search_result_struct *)
  321.         s_malloc((size_t)(length * sizeof(search_result_struct)));
  322.     operand_id = 0;
  323.   }
  324. }
  325.  
  326. static boolean make_doc_ids_array _AP((long pos, long length));
  327. static boolean make_doc_ids_array(pos, length)
  328.      long pos;
  329.      long length;
  330. {
  331.   /* if(search_result_array[pos].doc_ids_array == NULL) */
  332.   search_result_array[pos].doc_ids_array =
  333.     (doc_descr_struct *)
  334.       s_malloc((size_t)(sizeof(doc_descr_struct) * length));
  335.   if(search_result_array[pos].doc_ids_array == NULL) {
  336.     waislog(WLOG_HIGH, WLOG_ERROR, "Out of memory");
  337.     return(false);
  338.   }
  339.   return(true);
  340. }
  341. /* tung, 10/93 */
  342. #endif
  343.  
  344. /* make_document_score_array insures that the document_score_array
  345.    array is long enough, if not it makes it long enough */
  346. static void make_document_score_array _AP((long length ));
  347. static void make_document_score_array(length)
  348. long length;
  349. {
  350.   if(length <= document_score_array_len)
  351.     return;
  352.   /* we have to make a new one.  free the old one first (if any) */
  353.   if(document_score_array != 0){
  354.     s_free(document_score_array);
  355. #ifdef NESTED_BOOLEANS /* tung, 1/94 */
  356.     s_free(NumPart_score_array);
  357. #else
  358. #ifdef BOOLEANS
  359.     s_free(prev_score_array);                    /* 12/91 GS TLG */
  360. #endif
  361. #endif
  362.   }
  363.   document_score_array = (double*)s_malloc((size_t)(length * sizeof(double)));
  364. #ifdef NESTED_BOOLEANS /* tung, 1/94 */
  365.   NumPart_score_array   = (double*)s_malloc((size_t)(length * sizeof(double)));
  366.   memset(NumPart_score_array, 0,
  367.      document_score_array_len * sizeof(double));
  368. #else
  369. #ifdef BOOLEANS
  370.   prev_score_array   = (double*)s_malloc((size_t)(length * sizeof(double)));  /* 12/91 GS TLG */
  371. #endif
  372. #endif
  373.   document_score_array_len = length;
  374. }
  375.  
  376. static void destroy_document_score_array _AP((void));
  377. static void destroy_document_score_array()
  378. {
  379.   s_free(document_score_array);
  380. #ifdef NESTED_BOOLEANS /* tung, 1/94 */
  381.   s_free(NumPart_score_array);
  382. #else
  383. #ifdef BOOLEANS
  384.   s_free(prev_score_array);                    /* 12/91 GS TLG */
  385. #endif
  386. #endif
  387.   document_score_array_len = 0;
  388. }
  389.     
  390. void clear_document_score_array()
  391.      /* side effects the document_score_array. */
  392. { 
  393.   memset(document_score_array, 0, 
  394.      document_score_array_len * sizeof(double));
  395. #ifdef NESTED_BOOLEANS /* tung, 1/94 */
  396.   memset(NumPart_score_array, 0,
  397.          document_score_array_len * sizeof(double));
  398. #else
  399. #ifdef BOOLEANS
  400.   memset(prev_score_array, 0,                    /* 12/91 GS TLG */
  401.          document_score_array_len * sizeof(double));        /* 12/91 GS TLG */
  402. #endif
  403. #endif
  404. }
  405.  
  406. /* for debugging purposes */
  407. void print_document_score_array(start,stop)
  408. unsigned long start;
  409. unsigned long stop;
  410. /* assumes start >= 0, stop < db->doc_table_allocated_entries */
  411. {
  412.     long i;
  413.     for(i = start; i <= stop; i++){
  414.         printf("entry number %d: %f \n", 
  415.                i, document_score_array[i]);
  416.     }
  417. }
  418.  
  419.  
  420.  
  421. /*=========================*
  422.  *===  Best Hits Array  ===*
  423.  *=========================*/
  424.  
  425. hit *best_hits_array = NULL;
  426. long best_hits_array_len = 0;
  427. long current_best_hit = 0;
  428. long doc_start = 0; /* tung, 5/94 */
  429. long doc_end = 0;   /* tung, 5/94 */
  430.  
  431. /* see irext.h for doc */
  432. long init_best_hit (db)
  433.      database *db;
  434. {
  435.  
  436. #ifdef BOOL
  437.   if (currentQuery != NULL)
  438.     send(currentQuery,InitBestHit,db);
  439. #endif /* def BOOL */
  440.  
  441.   return(0);
  442. }
  443.  
  444. /* make_best_hits_array insures that the best_hits_array
  445.    array is long enough, if not it makes it long enough */
  446. static void make_best_hits_array _AP((long length));
  447. static void make_best_hits_array(length)
  448. long length;
  449. {
  450.   if(length <= best_hits_array_len)
  451.     return;
  452.   /* we have to make a new one.  free the old one first (if any) */
  453.   if(best_hits_array != 0){
  454.     s_free(best_hits_array);
  455.   }
  456.   best_hits_array = (hit*)s_malloc((size_t)(length * sizeof(hit)));
  457.   best_hits_array_len = length;
  458. }
  459.  
  460. static void destroy_best_hits_array _AP((void));
  461. static void destroy_best_hits_array()
  462. {
  463.   s_free(best_hits_array);
  464.   best_hits_array_len = 0;
  465. }
  466.     
  467. void clear_best_hits_array()
  468. /* side effects the best_hits_array.  XXX could use memset */
  469. { 
  470.   memset((char*)best_hits_array, 0, best_hits_array_len * sizeof(hit));
  471. }
  472.  
  473. /* for debugging purposes */
  474. void print_best_hits()
  475. {
  476.   long i;
  477.   for( i = 0; i < best_hits_array_len; i++){
  478.     if (best_hits_array[i].weight != 0)
  479.       { printf("Best hit %ld: weight %lf, doc_id %ld, headline %s, filename %s, lines %ld\n", 
  480.            i, best_hits_array[i].weight, 
  481.            best_hits_array[i].document_id,
  482.            best_hits_array[i].headline,
  483.            best_hits_array[i].filename,
  484.            best_hits_array[i].number_of_lines);
  485.       }
  486.   }
  487. }
  488.  
  489. void sort_best_hits(db)
  490.      database * db;
  491. {
  492.   /* returns nothing.
  493.    * side effects best_hits and document_score_array
  494.    */
  495.  
  496.   long i, doc;
  497.   double worst_weight_to_make_it = 0.0;
  498.   document_table_entry doc_entry;
  499.   long best_hit_number = 0;
  500.  
  501.   /* snuff the scores */
  502.   for(i = 0; i < max_hit_retrieved; i++){
  503.     best_hits_array[i].weight = 0.0;
  504.  
  505.   }
  506.  
  507.   /* loop over the doc, and keep the doc_id and weight in best hit table */
  508.   /* for(doc = 0; doc < db->doc_table_allocated_entries; doc++){ */
  509.   for(doc = doc_start; doc <= doc_end; doc++) {
  510.     double weight = document_score_array[doc];
  511.     /* jmf */
  512.     if(weight > 0) {
  513. #ifndef NEW_WEIGHT /* tung, 5/94 */
  514.       read_document_table_entry(&doc_entry, doc, db);  /* if this could be
  515.                               removed, we'd gain speed */
  516.       if (doc_entry.document_length)
  517.     weight/=doc_entry.document_length;
  518.       else
  519.         weight = 0;
  520. #endif
  521.       if(worst_weight_to_make_it < weight){
  522.     /* merge it into the best_hits array. start at the bottom */
  523.     for(i = (max_hit_retrieved - 1); i >= 0; i--){
  524.       if(weight > best_hits_array[i].weight 
  525.          /* && (check_document_id(doc, db) == true) too slow.*/
  526.          ){
  527.         /* move this entry down */    
  528.         if((i + 1) < max_hit_retrieved){
  529.           best_hits_array[i+1].weight = best_hits_array[i].weight;
  530.           best_hits_array[i+1].document_id = best_hits_array[i].document_id;
  531.         }
  532.         best_hits_array[i].document_id = doc;
  533.         best_hits_array[i].weight = weight;
  534.       }
  535.       else
  536.         break;
  537.     }      
  538.       }
  539.     }
  540.   }
  541.   doc_start = doc_end = 0; /* tung, 5/94 */
  542.   for(i = 0; i < max_hit_retrieved; i++){
  543.     if(best_hits_array[i].weight <= 0.0)
  544.       return;
  545.     if (read_document_table_entry(&doc_entry,
  546.                   best_hits_array[i].document_id,
  547.                   db) 
  548.     == true){
  549.       best_hits_array[best_hit_number].weight = best_hits_array[i].weight;
  550.  
  551.       best_hits_array[best_hit_number].document_id = best_hits_array[i].document_id;
  552.       best_hits_array[best_hit_number].start_character = doc_entry.start_character;
  553.       best_hits_array[best_hit_number].end_character = doc_entry.end_character;
  554.       best_hits_array[best_hit_number].document_length = doc_entry.document_length;
  555.       best_hits_array[best_hit_number].number_of_lines = doc_entry.number_of_lines;
  556.       sprintf(best_hits_array[best_hit_number].date, "%d", doc_entry.date);
  557.       read_filename_table_entry(doc_entry.filename_id, 
  558.                 best_hits_array[best_hit_number].filename,
  559.                 best_hits_array[best_hit_number].type,
  560.                 NULL,
  561.                 db),
  562.       strncpy(best_hits_array[best_hit_number].headline, 
  563.           read_headline_table_entry(doc_entry.headline_id,db),
  564.           MAX_HEADLINE_LEN);
  565.       best_hit_number++;
  566.     } 
  567.     beFriendly();
  568.   }
  569.   for(i = best_hit_number; i < max_hit_retrieved; i++){
  570.     best_hits_array[best_hit_number].weight = 0.0;
  571.   }
  572.   /* print_best_hits(s);  for debugging */
  573. }
  574.  
  575.  
  576. /* returns the next best hit */
  577. long best_hit(db, doc_id, best_character, best_line, score,start,end,date,
  578. length,nlines,headline,filename,type)
  579.      database *db;
  580.      long *doc_id;    
  581.      long *best_character;
  582.      long *best_line;
  583.      double *score;
  584.     long *start,*end,*date,*length,*nlines;
  585. char *headline,*filename,*type;
  586. {
  587. double tmp;
  588.  
  589.   *best_character = 0; 
  590.   *best_line = 0;
  591.   
  592. #ifdef BOOL
  593.   if (currentQuery != NULL) /* for boolean */
  594.    {
  595.      send(currentQuery,GetBestHit,db,doc_id,best_character,best_line,score);
  596.      if (*doc_id > 0)
  597.        return(0); /* ok */
  598.      else
  599.        return(-1); /* no more docs */
  600.    }
  601. #endif /* BOOL */
  602.  
  603.   if(current_best_hit > best_hits_array_len)
  604.     return(1);
  605.   if(best_hits_array[current_best_hit].weight == 0.0)
  606.     return(1);
  607.   *doc_id = best_hits_array[current_best_hit].document_id;
  608.   tmp  = ((double)(best_hits_array[current_best_hit].weight*VALUE));
  609. *score=tmp;
  610. *start=best_hits_array[current_best_hit].start_character;
  611. *end=best_hits_array[current_best_hit].end_character;
  612. *date=atol(best_hits_array[current_best_hit].date);
  613. *length=best_hits_array[current_best_hit].document_length;
  614. *nlines=best_hits_array[current_best_hit].number_of_lines;
  615. strcpy(headline,best_hits_array[current_best_hit].headline);
  616. strcpy(filename,best_hits_array[current_best_hit].filename);
  617. strcpy(type,best_hits_array[current_best_hit].type);
  618.   current_best_hit++;
  619.   return(0);
  620. }
  621.  
  622. long finished_best_hit(db)
  623. database *db;
  624. { 
  625.  
  626. #ifdef BOOL
  627.   if (currentQuery != NULL) /* for boolean */
  628.    { send(currentQuery,Delete);
  629.      currentQuery = NULL;
  630.      return(0);
  631.    }
  632. #endif /* BOOL */
  633.  
  634.   /* if we are on a small machine, we might want to 
  635.      destroy_document_score_array */
  636.   clear_document_score_array();
  637.   clear_best_hits_array();
  638.   current_best_hit = 0;
  639.   return(0);
  640. }
  641.  
  642. /*=============================*    
  643.  *===  Searching for words  ===*
  644.  *=============================*/
  645.  
  646. /* see irext.h for doc */
  647. long init_search_word (db)
  648.      database* db;
  649. {
  650. char fn[256];
  651.   strcpy( fn,db->database_file );
  652.   strcat( fn,synonym_ext );
  653.   syn_ReadFile( fn,&db->syn_Table,&db->syn_Table_Size );
  654.  
  655.   return(0);
  656. }
  657.  
  658. #ifdef NESTED_BOOLEANS
  659. /* tung, 10/93 */
  660. extern long number_of_operands ;
  661. /* tung, 10/93 */
  662. #endif
  663.  
  664. #ifdef BOOLEANS
  665. static boolean   gLastAnd= false;
  666. static boolean   gLastNot= false;
  667. #endif
  668.  
  669. /* see irext.h for doc */
  670. long search_word(word,
  671. #ifdef FIELDS /* tung, 5/94 */
  672.          field_name,
  673. #endif
  674.          char_pos, line_pos, weight, doc_id, 
  675.          word_pair, db)
  676.      char *word; /* the word to be searched for */
  677. #ifdef FIELDS /* tung, 5/94 */
  678.      char *field_name;
  679. #endif
  680.      long char_pos;        /* the position of the start of the word */
  681.      long line_pos;        /* is this needed? not for signature system */
  682.      long weight;        /* how important the word looks syntactically,
  683.                    such as is it bold */
  684.      long doc_id;        /* current document, seed words is 0,
  685.                    then it increments into the relevant 
  686.                    document */
  687.      long word_pair;
  688.      database *db;
  689. {
  690.   /* this side effects the document_score_array,
  691.    * and downcases the word.
  692.    * Returns 0 if successful or word not present, 
  693.    * returns non-0 if an error.
  694.    *
  695.    */
  696.   
  697.   long not_full_flag = INDEX_BLOCK_FULL_FLAG; /* start out full so it will go on looking */
  698.   long count, index_block_size;
  699.   long internal_document_id,  number_of_valid_entries;
  700.   double internal_weight;
  701.   long index_file_block_number;
  702.   long number_of_occurances;
  703.  
  704.   FOUR_BYTE index_buffer_data[INDEX_ELEMENT_SIZE*(1024/4)];
  705.   char *index_buffer;
  706. #ifdef undef
  707.   char *i = index_buffer;       /* What the hell should be in i ? (up) */
  708. #endif
  709.   FILE *stream = NULL;
  710.  
  711.  
  712. #ifdef LITERAL
  713.   long txt_pos, icnt, wcnt, pcnt;                    /* 2/92 GS TLG */
  714.   document_table_entry doc_entry;                    /* 2/92 GS TLG */
  715.   static FILE *txt_stream = NULL;                    /* 2/92 GS TLG */
  716.   char cmpr_word[MAX_PHRASE_LENGTH + 1];                /* 2/92 GS TLG */
  717.   /*char phrase[MAX_PHRASE_LENGTH + 1];    */                /* 2/92 GS TLG */
  718.   char txt_filename[MAX_FILENAME_LEN + 1];                /* 2/92 GS TLG */
  719.   char *temp_txt_filename = NULL;                    /* francois */
  720.   char prev_txt_filename[MAX_FILENAME_LEN + 1];                /* 2/92 GS TLG */
  721.   char txt_type[MAX_TYPE_LEN + 1];                    /* 2/92 GS TLG */
  722.   long phraselen= 0, txt_pos_fix= 0;
  723.   char *document_section = NULL;     /* tung , 10/93 */
  724.   long document_section_len = 0;     /* tung , 10/93 */
  725.   long phrase_readed = 0;            /* tung , 10/93 */
  726.   long phrase_count = 0;             /* tung , 10/93 */
  727.   boolean phrase_found = false;      /* tung , 10/93 */
  728. #endif
  729.  
  730. #ifdef NESTED_BOOLEANS /* tung, 10/93 */
  731.   long numeric_partial_valid_entries = 0;
  732. #endif
  733.  
  734. #ifdef NEW_WEIGHT /* tung, 5/94 */
  735.   double query_wgt;
  736. #else
  737.   double idf;
  738. #endif
  739. #ifdef FIELDS /* tung, 12/93 */
  740.   long field_id = -1;
  741.   boolean SearchField = false;
  742. #endif
  743.  
  744.   /* do synonym conversion */
  745.   
  746.   /* in theory, one can replace a word with a boolean phrase */
  747.   char *newword;
  748.  
  749.   newword = lookup_Synonym( word,db->syn_Table,db->syn_Table_Size );
  750.   waislog(WLOG_HIGH,WLOG_INFO,"Word %s Syn %s",word,newword);
  751.   strncpy(word,newword,MAX_WORD_LENGTH);
  752.  
  753. #ifdef FIELDS /* tung, 12/93 */
  754.   if(db->number_of_fields > 0) {
  755.     if(*field_name != '\0') {
  756.       if(strcmp(field_name, FREE_TEXT_FIELD) == 0) { /* global database */
  757.     field_name = "\0";
  758.         SearchField = false;
  759.     field_id = -1;
  760.       } else { 
  761.     SearchField = true;
  762.     field_id = pick_up_field_id(field_name, db);
  763.       }
  764.     }
  765.   }
  766. #endif
  767.   
  768. /* tung, 10/93 */
  769. #ifdef NESTED_BOOLEANS
  770.   if(number_of_operands > 1) {
  771.     make_search_result_array(number_of_operands);
  772.     if((weight!=LITERAL_FLAG) && IsOperator(word)) {
  773.       boolean_operations(word, search_result_array);
  774.       return(0);
  775.     }
  776.     if(strlen(word) == 1) {
  777.       search_result_array[operand_id].number_of_hits = 0;
  778.       search_result_array[operand_id].operand_id = operand_id;
  779.       if(!save_operand_id(operand_id, search_result_array, db->doc_table_allocated_entries))
  780.     return(-1);
  781.       ++operand_id;
  782.       return(0);
  783.     }
  784.   }
  785. #endif
  786. /* tung, 10/93 */
  787.  
  788.   /* francois - call the stemmer */
  789. #ifdef FIELDS /* tung, 1/94 */
  790.   if(weight!=LITERAL_FLAG &&  weight!= FIELD_FLAG && weight!= NUMERIC_FLAG) {
  791. #ifdef STEM_WORDS
  792.     if(field_id > -1) {
  793.       if(db->fields[field_id].stemming)
  794.     stemmer(word);  
  795.     }
  796.     else {
  797.       if(db->stemming)
  798.     stemmer(word);
  799.     }
  800. #endif
  801.   }
  802. #else
  803. #ifdef LITERAL
  804.   if (weight!=LITERAL_FLAG) {
  805.     stemmer(word); 
  806.   }
  807. #else
  808.   stemmer(word); 
  809. #endif
  810. #endif
  811.  
  812. #ifdef LITERAL
  813.   if (weight==LITERAL_FLAG) {
  814.     /* goto after_booleans */
  815. /* printf("search_word: literal word is [%s]\n", word); */
  816.     }
  817.   else 
  818. #endif
  819.  
  820. #ifndef NESTED_BOOLEANS /* 10,93 */
  821. #ifdef BOOLEANS
  822.   if (strcmp(word,BOOLEAN_AND)==0) {  /* should be all lowercase cmp here */
  823.     gLastAnd= true;
  824.     return(0);
  825.     }
  826.   else if (strcmp(word,BOOLEAN_NOT)==0) {  
  827.   /* ^^ this is bad if we intersperse "not"s in a query --
  828.      docs found after not word may include notted word --
  829.      need to go back to doing not words after others --
  830.      but need now to check for literal string first
  831.   */
  832.     gLastNot= true;
  833.     return(0);
  834.   }
  835.   if (weight == BOOLEAN_NOT_FLAG) gLastNot= true;
  836. #else
  837.      ;   /* if not LITERAL_FLAG */
  838. #endif
  839. #endif /* #ifndef NESTED_BOOLEANS */
  840.  
  841.   index_buffer = (char*)index_buffer_data;
  842.  
  843. #ifdef LITERAL
  844.   if (weight==LITERAL_FLAG) {
  845.   /* note: we found the first word of phrase once in map_over_words, but i'm too lazy 
  846.       to put another parameter in that cascade of function calls it takes
  847.     to get here.
  848.   */
  849.     char  word1[MAX_WORD_LENGTH + 1];
  850.     register int i, len;
  851.     register boolean more;
  852.     phraselen= MINIMUM( MAX_PHRASE_LENGTH, strlen(word));
  853.     len = MINIMUM( MAX_WORD_LENGTH, phraselen);
  854.     for (i=0, more=true; i < len && more; ) {
  855.       word1[i] = word[i++];
  856. #ifdef BIO
  857.       more= (wordDelimiter(word[i]) == NOT_DELIMITER); 
  858. #else
  859.       more= (isalnum(word[i]));
  860. #endif
  861.      }
  862.     word1[i]= '\0';
  863.     txt_pos_fix= strlen(word1) + 1;
  864. /* printf("search_word: literal word1 is [%s]\n", word1); */
  865. #ifdef FIELDS /* tung, 1/94 */
  866.     if((db->number_of_fields == 0) && !SearchField)
  867.       index_file_block_number = 
  868.         look_up_word_in_dictionary(word1, &number_of_occurances, db);
  869.     else 
  870.       index_file_block_number = 
  871.         field_look_up_word_in_dictionary(field_name, word1, &number_of_occurances, db);
  872. #else
  873.     index_file_block_number = 
  874.       look_up_word_in_dictionary(word1, &number_of_occurances, db);
  875. #endif
  876.   }
  877.   else
  878. #endif  /* LITERAL */
  879.  
  880. #ifdef PARTIALWORD
  881. #ifdef FIELDS /* tung, 1/94 */
  882.     index_file_block_number = 
  883.       look_up_partialword_in_dictionary(field_name, 
  884.                                         word, &number_of_occurances, db);
  885. #else
  886.     index_file_block_number = 
  887.       look_up_partialword_in_dictionary(word, &number_of_occurances, db);
  888. #endif
  889. #else
  890.   index_file_block_number = 
  891.     look_up_word_in_dictionary(word, &number_of_occurances, db);
  892. #endif
  893.  
  894.   current_best_hit = 0;  /* so that the best hits willstart from 0 */
  895.  
  896.   /* check the document_score_array */
  897.   if(document_score_array_len < db->doc_table_allocated_entries)
  898.     make_document_score_array(db->doc_table_allocated_entries);
  899.  
  900.   if(index_file_block_number >= 0){
  901. #ifdef PARTIALWORD
  902.    while(index_file_block_number > 0){  /* dgg, need 2nd loop here for multiple partwords */
  903. #endif
  904.  
  905. #ifdef FIELDS /* tung, 1/94 */
  906.      if(SearchField && *field_name != '\0') 
  907.        stream = db->field_index_streams[pick_up_field_id(field_name, db)];
  908.      else stream = db->index_stream;
  909. #else
  910.      stream = db->index_stream;
  911. #endif
  912.  
  913.     while((not_full_flag != INDEX_BLOCK_NOT_FULL_FLAG) && 
  914.       (index_file_block_number != 0)){    
  915.       /* read the index block */
  916.       if (0 != fseek(stream, (long)index_file_block_number, 
  917.              SEEK_SET))    
  918.     { 
  919.       waislog(WLOG_HIGH, WLOG_ERROR, 
  920.           "fseek failed into the inverted file to position %ld",
  921.           (long)index_file_block_number); 
  922. #ifdef BOOLEANS
  923.    gLastNot= gLastAnd= false;
  924. #endif  
  925.       return(-1);
  926.     }
  927. /*      
  928.       read(fileno(stream),index_buffer,INDEX_BLOCK_HEADER_SIZE);
  929.  
  930.       ASSIGN(not_full_flag,
  931.          INDEX_BLOCK_FLAG_SIZE,
  932.          index_buffer,
  933.          INDEX_BLOCK_HEADER_SIZE,
  934.          0 );
  935.       ASSIGN(index_file_block_number,NEXT_INDEX_BLOCK_SIZE,
  936.          index_buffer+INDEX_BLOCK_FLAG_SIZE,
  937.          INDEX_BLOCK_HEADER_SIZE,
  938.          INDEX_BLOCK_FLAG_SIZE);
  939.       ASSIGN(index_block_size,INDEX_BLOCK_SIZE_SIZE,
  940.          index_buffer+INDEX_BLOCK_FLAG_SIZE+NEXT_INDEX_BLOCK_SIZE,
  941.          INDEX_BLOCK_HEADER_SIZE,
  942.          INDEX_BLOCK_FLAG_SIZE+NEXT_INDEX_BLOCK_SIZE);
  943.  
  944.   this is equivalent, but slower:
  945. */
  946.       not_full_flag = read_bytes(INDEX_BLOCK_FLAG_SIZE, stream);
  947.       index_file_block_number = read_bytes(NEXT_INDEX_BLOCK_SIZE, stream);
  948.       index_block_size = read_bytes(INDEX_BLOCK_SIZE_SIZE, stream);
  949.  
  950. /*  Jim's debug code commented out
  951.       printf("flag = %d, block_num = %d, block_size = %d\n",
  952.          not_full_flag, 
  953.          index_file_block_number,
  954.          index_block_size);
  955. */
  956.       fflush(stdout);
  957.  
  958.       if(EOF == index_block_size) 
  959.     { 
  960.       waislog(WLOG_HIGH, WLOG_ERROR, 
  961.           "reading from the index file failed");
  962. #ifdef BOOLEANS
  963.    gLastNot= gLastAnd= false;
  964. #endif  
  965.       return(-1);
  966.     }
  967.       
  968.       if(not_full_flag == INDEX_BLOCK_NOT_FULL_FLAG){
  969.     /* not full */
  970.     number_of_valid_entries = index_file_block_number;
  971.       }
  972.       else if(not_full_flag == INDEX_BLOCK_FULL_FLAG){
  973.     /* full */
  974.     number_of_valid_entries = index_block_size - INDEX_BLOCK_HEADER_SIZE;
  975.       }
  976.       else{            /* bad news, file is corrupted. */
  977.     waislog(WLOG_HIGH, WLOG_ERROR, 
  978.         "Expected the flag in the inverted file to be valid.  it is %ld",
  979.         not_full_flag);
  980. #ifdef BOOLEANS
  981.    gLastNot= gLastAnd= false;
  982. #endif  
  983.     return(-1);
  984.       }
  985.       /* printf("number of valid bytes: %ld\n", number_of_valid_entries); */
  986.       
  987.       /* add the array to the document_score_array */
  988.       number_of_valid_entries /= INDEX_ELEMENT_SIZE;
  989.  
  990. /* tung, 10/93 */
  991. #ifdef NESTED_BOOLEANS   
  992.       if((number_of_operands > 1) && (search_result_array != NULL)) {
  993. #ifdef FIELDS /* tung, 1/94 */
  994.         if(weight != NUMERIC_FLAG && weight != PARTIAL_FLAG) {
  995. #else
  996.         if(weight != PARTIAL_FLAG) {
  997. #endif
  998.           if(!make_doc_ids_array(operand_id, db->doc_table_allocated_entries))
  999.         return(-1);
  1000.           search_result_array[operand_id].number_of_hits = number_of_valid_entries;
  1001.         }
  1002.       }
  1003. #endif
  1004. /* tung, 10/93 */
  1005.  
  1006. #ifdef NEW_WEIGHT /* tung, 5/94 */      
  1007.     query_wgt = 1;
  1008. #else
  1009.     /* ses - idf is a fist approximation to the inverse document freq. */
  1010.     /* what it actually is  is the inverse occurance frequency which says
  1011.      * that the significance of a word is inversly proportional to the number
  1012.      * of times it occurs in the database */
  1013.  
  1014.     idf=1.0/number_of_occurances; 
  1015. #endif
  1016.       for(count=0;count <  number_of_valid_entries;count++) {
  1017.     int wgt;
  1018.     int did;
  1019. /*
  1020.     if(count%1024 == 0) {
  1021.       read(fileno(stream),index_buffer,INDEX_ELEMENT_SIZE*
  1022.         MINIMUM(1024,number_of_valid_entries-count));
  1023.       i=index_buffer;
  1024.     }
  1025. */
  1026.     did = read_bytes(DOCUMENT_ID_SIZE, stream);
  1027.         (void)read_bytes(WORD_POSITION_SIZE, stream);
  1028.         txt_pos=read_bytes(CHARACTER_POSITION_SIZE, stream);
  1029.         wgt = read_bytes(WEIGHT_SIZE,stream);
  1030. #ifdef NEW_WEIGHT /* tung, 5/94 */
  1031.     internal_weight = read_weight_from_stream(NEW_WEIGHT_SIZE, stream);
  1032. #endif
  1033. /*
  1034.  
  1035.     ASSIGN(wgt,WEIGHT_SIZE,    
  1036.            i+DOCUMENT_ID_SIZE+WORD_POSITION_SIZE+CHARACTER_POSITION_SIZE,
  1037.            INDEX_ELEMENT_SIZE,
  1038.            DOCUMENT_ID_SIZE+WORD_POSITION_SIZE+CHARACTER_POSITION_SIZE);
  1039.     ASSIGN(did,DOCUMENT_ID_SIZE,i,INDEX_ELEMENT_SIZE,0);
  1040. */
  1041. #ifdef LITERAL
  1042.     /* dgg -- is this proper update of read form to ASSIGN form ??*/
  1043.     /* txt_pos = read_bytes(CHARACTER_POSITION_SIZE, stream);*/        /* 2/92 GS TLG */
  1044.         if ((weight == LITERAL_FLAG) && (0 == doc_id))  {         
  1045. /*
  1046.     ASSIGN(txt_pos,CHARACTER_POSITION_SIZE,i+DOCUMENT_ID_SIZE+WORD_POSITION_SIZE,
  1047.         INDEX_ELEMENT_SIZE,DOCUMENT_ID_SIZE+WORD_POSITION_SIZE);
  1048. */
  1049. /* printf("search_word: txtpos=%d, wgt=%d, did=%d\n", txt_pos, wgt, did); */
  1050.         }
  1051. #endif
  1052.  
  1053. /* Commented out as suggested by Stan Isaacs at hp.com to come up with correct
  1054.  * weights when there are multiple documents in a file
  1055.  *
  1056.  *    if(wgt>5L)
  1057.  *        wgt-=5L;
  1058.  */
  1059. #ifndef NEW_WEIGHT /* tung, 5/94 */
  1060.     internal_weight = log((double)wgt);
  1061.     internal_weight+=10.0;
  1062. #endif
  1063.     internal_document_id = did;
  1064.     if((doc_start == 0) && (doc_end == 0)) /* tung, 5/94 */
  1065.       doc_start = doc_end = did;           /* tung, 5/94 */
  1066.     doc_start = MINIMUM(doc_start, did);   /* tung, 5/94 */
  1067.     doc_end = MAXIMUM(doc_end, did);       /* tung, 5/94 */
  1068.  
  1069. /*
  1070.     printf("entry %ld, Doc_id: %ld, weight %lf \n",
  1071.         count, internal_document_id, internal_weight);
  1072.     fflush(stdout);
  1073. */
  1074.     if(EOF == wgt) 
  1075.       { 
  1076.         waislog(WLOG_HIGH, WLOG_ERROR, 
  1077.             "reading from the doc-id table failed");
  1078. #ifdef BOOLEANS
  1079.    gLastNot= gLastAnd= false;
  1080. #endif  
  1081.         return(-1);
  1082.       }
  1083.  
  1084. #ifdef LITERAL         
  1085.         if ((weight == LITERAL_FLAG) && (0 == doc_id)) {        /* 2/92 GS TLG */
  1086.           if (true == read_document_table_entry(&doc_entry,        /* 2/92 GS TLG */
  1087.                                              internal_document_id, db)) /* 2/92 GS TLG */
  1088.        {                                /* 2/92 GS TLG */
  1089.             read_filename_table_entry(doc_entry.filename_id,        /* 2/92 GS TLG */
  1090.                                       txt_filename, txt_type, NULL, db);  /* 2/92 GS TLG */
  1091. /* printf("search_word: document is [%s]\n", txt_filename); */
  1092.             if (NULL == txt_stream) {
  1093.               /* francois */
  1094.               if (probe_file(txt_filename)) {
  1095.                 txt_stream = s_fopen(txt_filename, "rb");
  1096.               }
  1097.               else if (probe_file_possibly_compressed(txt_filename)) {
  1098.                temp_txt_filename = s_fzcat(txt_filename);
  1099.                if (temp_txt_filename) {
  1100.              txt_stream = s_fopen(temp_txt_filename, "rb");
  1101.             }
  1102.            }
  1103.            
  1104.               strcpy(prev_txt_filename, txt_filename);
  1105.              }
  1106.             else if (0 != strcmp(txt_filename, prev_txt_filename)) {
  1107.               s_fclose(txt_stream);
  1108.               /* francois */
  1109.               if ( temp_txt_filename != NULL ) {
  1110.                 unlink(temp_txt_filename);
  1111.                 s_free(temp_txt_filename);
  1112.               }
  1113.               if (probe_file(txt_filename)) {
  1114.                 txt_stream = s_fopen(txt_filename, "rb");
  1115.               }
  1116.               else if (probe_file_possibly_compressed(txt_filename)) {
  1117.                temp_txt_filename = s_fzcat(txt_filename);
  1118.                if (temp_txt_filename) {
  1119.              txt_stream = s_fopen(temp_txt_filename, "rb");
  1120.              }
  1121.            }
  1122.               strcpy(prev_txt_filename, txt_filename);        /* 2/92 GS TLG */
  1123.               }
  1124.  
  1125.             txt_pos += doc_entry.start_character - txt_pos_fix;  /* dgg */
  1126.             document_section_len = doc_entry.end_character - txt_pos;   /* tung, 10/93 */
  1127.             s_fseek(txt_stream, txt_pos, SEEK_SET);            /* 2/92 GS TLG */
  1128.             document_section = 
  1129.               (char*) s_malloc((size_t)((document_section_len+1)*sizeof(char))); /* tung, 10/93 */
  1130.             fgets(document_section, document_section_len, txt_stream);   /* tung, 10/93 */
  1131.             phrase_readed = 0;                                           /* tung, 10/93 */
  1132.             phrase_readed += strlen(document_section);                   /* tung, 10/93 */
  1133.             document_section = string_downcase(document_section);        /* tung, 10/93 */
  1134. #if 0
  1135.             fread(phrase, 1L, phraselen, txt_stream);            /* 2/92 GS TLG */
  1136.             /* { phrase[phraselen]= '\0';
  1137.                printf("search_word: file phrase is [%s]\n", phrase); 
  1138.                } */
  1139.             if (0 != strncasecmp(word, phrase, phraselen))        /* 2/92 GS TLG */
  1140.               internal_weight = 0.0;                                    /* 2/92 GS TLG */
  1141. #endif                
  1142.             if (NULL == strstr(document_section, word)) {                    /* tung, 10/93 */
  1143.               while(phrase_readed < document_section_len) {                  /* tung, 10/93 */
  1144.                 fgets(document_section, document_section_len, txt_stream);   /* tung, 10/93 */
  1145.                 phrase_readed += strlen(document_section);                   /* tung, 10/93 */
  1146.                 document_section = string_downcase(document_section);        /* tung, 10/93 */
  1147.                 if(strstr(document_section, word) != NULL)  {                /* tung, 10/93 */
  1148.                   phrase_found = true;                                       /* tung, 10/93 */
  1149.                   break;                                                     /* tung, 10/93 */
  1150.                 }                                                            /* tung, 10/93 */
  1151.               }                                                              /* tung, 10/93 */
  1152.               if(phrase_found == false)                                      /* tung, 10/93 */
  1153.                 internal_weight = 0.0;                         /* tung, 10/93 */
  1154.               phrase_found = false;                                          /* tung, 10/93 */
  1155.             } 
  1156.             s_free(document_section);                                        /* tung, 10/93 */
  1157.           }
  1158.         }                                
  1159. #endif
  1160.  
  1161. #ifndef NESTED_BOOLEANS /* 10,93 */
  1162. #ifdef BOOLEANS
  1163.     if (gLastNot) {    
  1164.        document_score_array[internal_document_id] = 0;
  1165. /*     printf("search_word: boolean 'not' scored\n"); */
  1166.         }
  1167.         else 
  1168. #endif
  1169. #endif /* #ifndef NESTED_BOOLEANS */
  1170.     {
  1171.     /* if(doc_id > 0) we are doing a relevant document */
  1172. /*
  1173. printf("wgt: %ld, internal weight: %lf, idf: %lf occurances: %ld\n",
  1174.     wgt,internal_weight, idf,number_of_occurances);
  1175. fflush(stdout);
  1176. */
  1177. #ifndef NEW_WEIGHT /* tung, 5/94 */
  1178.         internal_weight*=idf; /* ses - for inverse doc. freq. */
  1179. #endif
  1180. #ifndef NESTED_BOOLEANS
  1181. #ifdef NEW_WEIGHT /* tung, 5/94 */
  1182.     document_score_array[internal_document_id] += 
  1183.       (query_wgt *  internal_weight);
  1184. #else
  1185.     document_score_array[internal_document_id] += 
  1186.       (doc_id) ? (internal_weight * RF_WEIGHTING) : internal_weight;
  1187. #endif
  1188. #else
  1189. /* tung, 10/93 */
  1190.         if(number_of_operands == 1) {
  1191. #ifdef NEW_WEIGHT /* tung, 5/94 */
  1192.       document_score_array[internal_document_id] += 
  1193.         (query_wgt *  internal_weight);
  1194. #else
  1195.           document_score_array[internal_document_id] += 
  1196.         (doc_id) ? (internal_weight * RF_WEIGHTING) : internal_weight;
  1197. #endif
  1198.         }
  1199.         else {
  1200.           if((number_of_operands > 1) && (search_result_array != NULL)) {
  1201.             if(weight == LITERAL_FLAG) {
  1202. #ifdef NEW_WEIGHT /* tung, 5/94 */
  1203.           ((search_result_array[operand_id]).doc_ids_array[phrase_count]).score +=
  1204.         (query_wgt *  internal_weight);
  1205. #else
  1206.               ((search_result_array[operand_id]).doc_ids_array[phrase_count]).score +=
  1207.                 (doc_id) ? (internal_weight * RF_WEIGHTING) : internal_weight;
  1208. #endif
  1209.               if(((search_result_array[operand_id]).doc_ids_array[phrase_count]).score > 0) {
  1210.                 ((search_result_array[operand_id]).doc_ids_array[phrase_count]).doc_id = internal_document_id;
  1211.                 phrase_count++;
  1212.                 search_result_array[operand_id].number_of_hits = phrase_count;
  1213.               }
  1214.             }
  1215. #ifdef FIELDS /* tung, 1/94 */
  1216.             else if(weight == NUMERIC_FLAG || weight == PARTIAL_FLAG) {
  1217. #else
  1218.             else if(weight == PARTIAL_FLAG) {
  1219. #endif
  1220.               if(NumPart_score_array[internal_document_id] <= 0)
  1221.                 ++numeric_partial_valid_entries;
  1222. #ifdef NEW_WEIGHT /* tung, 5/94 */
  1223.           NumPart_score_array[internal_document_id] = 
  1224.         MAXIMUM(NumPart_score_array[internal_document_id], (query_wgt *  internal_weight));
  1225. #else
  1226.               NumPart_score_array[internal_document_id] += 
  1227.                 (doc_id) ? (internal_weight * RF_WEIGHTING) : internal_weight;
  1228. #endif
  1229.             }
  1230.             else {
  1231.               ((search_result_array[operand_id]).doc_ids_array[count]).doc_id = internal_document_id;
  1232. #ifdef NEW_WEIGHT /* tung, 5/94 */
  1233.           ((search_result_array[operand_id]).doc_ids_array[count]).score +=
  1234.         (query_wgt *  internal_weight);
  1235. #else
  1236.               ((search_result_array[operand_id]).doc_ids_array[count]).score +=
  1237.                 (doc_id) ? (internal_weight * RF_WEIGHTING) : internal_weight;
  1238. #endif
  1239.             }
  1240.           }
  1241.         }
  1242. #endif
  1243. /* tung, 10/93 */
  1244.         
  1245.       }
  1246. /*
  1247. printf("Score array: %lf\n",document_score_array[internal_document_id]);
  1248. fflush(stdout);
  1249. */
  1250.  
  1251.     /* i+=INDEX_ELEMENT_SIZE;  Purify (umr): uninitialized memory read: (up) */
  1252.       }
  1253.     }
  1254.  
  1255. #ifdef PARTIALWORD
  1256. #ifdef FIELDS /* tung, 1/94 */
  1257.   index_file_block_number = 
  1258.     look_up_partialword_in_dictionary(field_name, 
  1259.                                       NULL, &number_of_occurances, db);
  1260. #else
  1261.   index_file_block_number = 
  1262.     look_up_partialword_in_dictionary(NULL, &number_of_occurances, db);
  1263. #endif      
  1264.   }
  1265. #endif
  1266.  
  1267. #ifdef NESTED_BOOLEANS /* tung, 1/94 */
  1268.    if(number_of_operands > 1) {
  1269.      long index = 0;
  1270. #ifdef FIELDS /* tung, 1/94 */
  1271.      if(weight == NUMERIC_FLAG || weight == PARTIAL_FLAG) {
  1272. #else
  1273.      if(weight == PARTIAL_FLAG) {
  1274. #endif
  1275.        if(!make_doc_ids_array(operand_id, db->doc_table_allocated_entries))
  1276.      return(-1);
  1277.        search_result_array[operand_id].number_of_hits =
  1278.          numeric_partial_valid_entries;
  1279.        /*for (count=0; count < db->doc_table_allocated_entries; count++) {*/
  1280.        for (count=doc_start; count <= doc_end ; count++) {
  1281.          if(NumPart_score_array[count] > 0) {
  1282.            ((search_result_array[operand_id]).doc_ids_array[index]).doc_id = count;
  1283.            ((search_result_array[operand_id]).doc_ids_array[index]).score
  1284.              = NumPart_score_array[count];
  1285.            NumPart_score_array[count] = 0.0;
  1286.            ++index;
  1287.          }
  1288.          if(index == numeric_partial_valid_entries)
  1289.            break;
  1290.        }
  1291.      }
  1292.    }
  1293. #endif
  1294.  
  1295. /* tung, 10/93 */
  1296. #ifdef NESTED_BOOLEANS
  1297.     if((number_of_operands > 1) && (search_result_array != NULL)) {
  1298.       if(!save_operand_id(operand_id, search_result_array,db->doc_table_allocated_entries))
  1299.     return(-1);
  1300.       search_result_array[operand_id].operand_id = operand_id;
  1301.       ++operand_id;
  1302.     }
  1303. #endif 
  1304. /* tung, 10/93 */
  1305.  
  1306. #ifndef NESTED_BOOLEANS /* tung, 10/94 */
  1307. #ifdef BOOLEANS
  1308.    for (count=0; count < db->doc_table_allocated_entries; count++) {   /* 12/91 GS TLG */
  1309.      if (!gLastAnd) {                             /* 12/91 GS TLG */
  1310.        prev_score_array[count] = document_score_array[count];        /* 12/91 GS TLG */
  1311.      }                                 /* 12/91 GS TLG */
  1312.      else {                                   /* 12/91 GS TLG */
  1313.        if ((document_score_array[count] == prev_score_array[count])    /* 12/91 GS TLG */
  1314.            || (prev_score_array[count] == 0)) {
  1315.          document_score_array[count] = 0;                /* 12/91 GS TLG */
  1316.          prev_score_array[count] = 0;                    /* 12/91 GS TLG */
  1317.        }                                /* 12/91 GS TLG */
  1318.        else {  
  1319.          prev_score_array[count] = document_score_array[count];    /* 12/91 GS TLG */
  1320.        }                                /* 12/91 GS TLG */
  1321.      }                                    /* 12/91 GS TLG */
  1322.    }                                    /* 12/91 GS TLG */
  1323. /*  if (gLastAnd) printf("search_word: boolean `and' scored\n"); */
  1324. #endif
  1325. #endif 
  1326.  
  1327. #ifdef BOOLEANS
  1328.    gLastNot= gLastAnd= false;
  1329. #endif /* BOOLEANS */
  1330.     return(0); 
  1331.   }
  1332.   
  1333.   else if(0 == index_file_block_number){
  1334.     /* an error occurred on looking up the word */
  1335. #ifdef BOOLEANS
  1336.    gLastNot= gLastAnd= false;
  1337. #endif 
  1338.    return(-1);
  1339.  }
  1340.   
  1341.   else {                /* index_file_block_number is negative */
  1342. #ifdef NESTED_BOOLEANS /* tung, 10/93 */
  1343.     if((number_of_operands > 1) && (search_result_array != NULL)) {
  1344.       if(!save_operand_id(operand_id, search_result_array,db->doc_table_allocated_entries))
  1345.     return(-1);
  1346.       search_result_array[operand_id].operand_id = operand_id;
  1347.       search_result_array[operand_id].number_of_hits = 0;
  1348.       ++operand_id;
  1349.     }
  1350. #else
  1351. #ifdef BOOLEANS
  1352.     if (gLastAnd) 
  1353.       for (count=0; count < db->doc_table_allocated_entries; count++) {
  1354.         document_score_array[count] = 0;                       
  1355.         prev_score_array[count] = 0;   
  1356.       } 
  1357.     gLastNot= gLastAnd= false;
  1358. #endif
  1359. #endif 
  1360.     return(0);        /* word not present */
  1361.   }
  1362. }
  1363.  
  1364.  
  1365. /* now collect the best hits */
  1366. long finished_search_word(db)
  1367.      database *db;
  1368. { 
  1369. #ifdef NESTED_BOOLEANS
  1370.   long number_of_hits; /* tung, 10/93 */
  1371. #endif
  1372.  
  1373. #ifdef BOOL
  1374.   if (currentQuery != NULL)
  1375.     return; /* do nothing for boolean */
  1376. #endif /* def BOOL */
  1377.  
  1378. /* tung, 10/93 */
  1379. #ifdef NESTED_BOOLEANS
  1380.   if((number_of_operands > 1) && (search_result_array != NULL)) {
  1381.     number_of_hits = retriev_result(db->doc_table_allocated_entries, 
  1382.                                     document_score_array);
  1383.     clear_search_result_array(&number_of_operands);
  1384.   }
  1385. #endif
  1386. /* tung, 10/93 */
  1387.   
  1388.   /* check the document_score_array */
  1389.   if(document_score_array_len < db->doc_table_allocated_entries)
  1390.     make_document_score_array(db->doc_table_allocated_entries);
  1391.  
  1392.   make_best_hits_array(max_hit_retrieved);
  1393.   sort_best_hits(db);
  1394.   syn_Free( db->syn_Table,&db->syn_Table_Size );
  1395.  
  1396.   return(0);
  1397. }
  1398.  
  1399.